package com.shm.leetcode.concurrent;
/**
 * @author: shm
 * @dateTime: 2020/11/29 10:16
 * @description: 493. 翻转对
 * 给定一个数组 nums ，如果 i < j 且 nums[i] > 2*nums[j] 我们就将 (i, j) 称作一个重要翻转对。
 *
 * 你需要返回给定数组中的重要翻转对的数量。
 *
 * 示例 1:
 *
 * 输入: [1,3,2,3,1]
 * 输出: 2
 * 示例 2:
 *
 * 输入: [2,4,3,5,1]
 * 输出: 3
 * 注意:
 *
 * 给定数组的长度不会超过50000。
 * 输入数组中的所有数字都在32位整数的表示范围内。
 */
public class ReversePairs {
    public int reversePairs(int[] nums) {
        int cnt = 0;
        for (int i = 0; i < nums.length-1; i++) {
            for (int j = i+1; j < nums.length; j++) {
                if ((long)nums[i]>(long)2*(long)nums[j]){
                    cnt++;
                }
            }
        }
        return cnt;
    }

    /**
     * 前言
     * 本题与「327. 区间和的个数」非常相像。
     *
     * 在 327 题中，我们要对前缀和数组的每一个元素 \textit{preSum}[i]preSum[i]，找出所有位于 ii 左侧的下标 jj 的数量，要求 jj 满足 \textit{preSum}[j] \in [\textit{preSum}[i]-\textit{upper}, \textit{preSum}[i]-\textit{lower}]preSum[j]∈[preSum[i]−upper,preSum[i]−lower]。而在此题中，我们则要对数组中的每一个元素 \textit{sum}[i]sum[i]，找出位于 ii 左侧，且满足 \textit{nums}[j] > 2\cdot \textit{nums}[i]nums[j]>2⋅nums[i] 的下标 jj。
     *
     * 不难发现，二者都是要对数组中的每一个元素，统计「在它左侧，且取值位于某个区间」的元素数量。两个问题唯一的区别仅仅在于取值区间的不同，因此可以用相似的方法解决这两个问题。
     *
     * 在「327 题的题解：区间和的个数」中，我们介绍了归并排序、线段树、树状数组以及平衡搜索树等多种解法。对于本题，我们只给出基于归并排序与树状数组的方法，感兴趣的读者可以参照前面给出的链接，自行完成其他方法的代码。
     *
     * 方法一：归并排序
     * 思路及解法
     *
     * 在归并排序的过程中，假设对于数组 \textit{nums}[l..r]nums[l..r] 而言，我们已经分别求出了子数组 \textit{nums}[l..m]nums[l..m] 与 \textit{nums}[m+1..r]nums[m+1..r] 的翻转对数目，并已将两个子数组分别排好序，则 \textit{nums}[l..r]nums[l..r] 中的翻转对数目，就等于两个子数组的翻转对数目之和，加上左右端点分别位于两个子数组的翻转对数目。
     *
     * 我们可以为两个数组分别维护指针 i,ji,j。对于任意给定的 ii 而言，我们不断地向右移动 jj，直到 \textit{nums}[i] \le 2\cdot \textit{nums}[j]nums[i]≤2⋅nums[j]。此时，意味着以 ii 为左端点的翻转对数量为 j-m-1j−m−1。随后，我们再将 ii 向右移动一个单位，并用相同的方式计算以 ii 为左端点的翻转对数量。不断重复这样的过程，就能够求出所有左右端点分别位于两个子数组的翻转对数目。
     *
     * 复杂度分析
     * 时间复杂度：O(N\log N)O(NlogN)，其中 NN 为数组的长度。
     * 空间复杂度：O(N)O(N)，其中 NN 为数组的长度。
     *
     * 作者：LeetCode-Solution
     * 链接：https://leetcode-cn.com/problems/reverse-pairs/solution/fan-zhuan-dui-by-leetcode-solution/
     * @param nums
     * @return
     */
    public int reversePairs_2(int[] nums) {
        if (nums.length == 0) {
            return 0;
        }
        return reversePairsRecursive(nums, 0, nums.length - 1);
    }

    public int reversePairsRecursive(int[] nums, int left, int right) {
        if (left == right) {
            return 0;
        } else {
            int mid = (left + right) / 2;
            int n1 = reversePairsRecursive(nums, left, mid);
            int n2 = reversePairsRecursive(nums, mid + 1, right);
            int ret = n1 + n2;

            // 首先统计下标对的数量
            int i = left;
            int j = mid + 1;
            while (i <= mid) {
                while (j <= right && (long) nums[i] > 2 * (long) nums[j]) {
                    j++;
                }
                ret += j - mid - 1;
                i++;
            }

            // 随后合并两个排序数组
            int[] sorted = new int[right - left + 1];
            int p1 = left, p2 = mid + 1;
            int p = 0;
            while (p1 <= mid || p2 <= right) {
                if (p1 > mid) {
                    sorted[p++] = nums[p2++];
                } else if (p2 > right) {
                    sorted[p++] = nums[p1++];
                } else {
                    if (nums[p1] < nums[p2]) {
                        sorted[p++] = nums[p1++];
                    } else {
                        sorted[p++] = nums[p2++];
                    }
                }
            }
            for (int k = 0; k < sorted.length; k++) {
                nums[left + k] = sorted[k];
            }
            return ret;
        }
    }
}
